home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-19 / iritsm3s.zip / IRIT2RAY.DSK (.txt) < prev    next >
Turbo C Context File  |  1991-11-12  |  11KB  |  296 lines
  1. Turbo C Context File 
  2. MISC_LIB.LIB
  3. CAGD_LIB.LIB
  4. IRIT2RAY.C
  5. MISC_LIB.LIB
  6. CAGD_LIB.LIB
  7. IRIT2RAY.C
  8. MISC_LIB.LIB
  9. CAGD_LIB.LIB
  10. IRIT2RAY.C
  11. MISC_LIB.LIB
  12. CAGD_LIB.LIB
  13. IRIT2RAY.C
  14. MISC_LIB.LIB
  15. CAGD_LIB.LIB
  16. IRIT2RAY.C
  17. MISC_LIB.LIB
  18. CAGD_LIB.LIB
  19. IRIT2RAY.C
  20. MISC_LIB.LIB
  21. CAGD_LIB.LIB
  22. IRIT2RAY.C
  23. MISC_LIB.LIB
  24. CAGD_LIB.LIB
  25. IRIT2RAY.C
  26. MISC_LIB.LIB
  27. CAGD_LIB.LIB
  28. IRIT2RAY.C
  29. MISC_LIB.LIB
  30. CAGD_LIB.LIB
  31. IRIT2RAY.C
  32. MISC_LIB.LIB
  33. CAGD_LIB.LIB
  34. IRIT2RAY.C
  35. ..\MISC_LIB\IRITPRSR.C
  36. \C\POLY3D\*.C
  37. \C\MISC_LIB\*.H
  38. \C\SM\*.H
  39. ..\MISC_LIB\IRITPRSR.H
  40. *.BAK
  41. ..\SM\GEOMAT3D.C
  42. ..\SM\PROGRAM.H
  43. \C\POLY3D-R\WIGGLE.DAT
  44. ..\POLY3D-R\*.C
  45. ..\POLY3D-R\*.DAT
  46. *.GEO
  47. *.RAY
  48. *.GEOM
  49. *.DAT
  50. -P -M- -v saddle.mat saddle.bzr
  51. -M -v saddle.mat saddle.bzr
  52. arc90.bzr
  53. \c\poly3d\cube.dat
  54. \c\poly3d-r\wiggle.dat
  55. -f 7 \c\poly3d-r\wiggle.dat
  56. -f 15 \c\poly3d-r\wiggle.dat
  57. -f 5 f:\twiggle.dat
  58. -f 5 f:\t.dat
  59. -f 5 \c\poly3d-r\solid2.dat
  60. \c\poly3d-r\solid2.dat
  61. t.dat
  62. solid1c.dat
  63. solid1.dat
  64. void *.c
  65. struct *.c
  66. struct *.h
  67. for *.c
  68.  void *.c 
  69. printf *.c
  70. GraphicMode
  71. ScreenCursorC
  72. AllSrfs
  73. MyFree
  74. include
  75. FineNess
  76. PObject
  77. PObject -> RGB
  78. CrossP
  79. %9.6lg
  80. Trans
  81. TransColorTable[PObject -> Color]
  82. ..\CAGD_LIB\*.C
  83. ..\CAGD_LIB\CAGDMESH.C
  84. ..\CAGD_LIB\CAGDCOER.C
  85. ..\CAGD_LIB\BZR_WRT.C
  86. ..\CAGD_LIB\BZR_READ.C
  87. ..\CAGD_LIB\BZR_GEN.C
  88. ..\CAGD_LIB\CAGD_LIB.LIB
  89. CAGD_LIB.LIB
  90. MISC_LIB.LIB
  91. INTERACT.C
  92. PCGRAPH.C
  93. IRIT2RAY.C
  94. StringToken
  95. LastNormal
  96. Normal
  97. VNext
  98. VNextNext
  99. D:\C\MISC_LIB\IRITPRSR.H
  100. D:\C\IRIT2RAY\IRIT2RAY.C
  101. D:\C\POLY3D-R\COLORTBL.C
  102. D:\C\POLY3D-R\EVALCOLR.C
  103. D:\C\SM\GEOMAT3D.C
  104. D:\C\SM\PROGRAM.H
  105. F:\T.DAT
  106. F:\T.DAT
  107. D:\C\IRIT2RAY\IRIT2RAY.GEO
  108. D:\C\IRIT2RAY\IRIT2RAY.RAY
  109. D:\C\IRIT2RAY\IRIT2RAY.RAY
  110. D:\C\IRIT2RAY\IRIT2RAY.GEO
  111. D:\C\IRIT2RAY\IRIT2RAY.RAY
  112. D:\C\IRIT2RAY\IRIT2RAY.C
  113. D:\C\IRITFLTR\SOLID1.DAT
  114. D:\C\IRITFLTR\IRIT2RAY.C
  115. BGIDriverPath
  116. void GGInstallBGI(char *BGIDriverPath, char *NameMode)
  117. /*****************************************************************************
  118. * Routine to draw all the objects in object list Objects.             *
  119. *****************************************************************************/
  120. void DrawAllObjects(IPObjectStruct *Objects)
  121.     while (Objects) {
  122.     DrawOneObject(Objects);
  123.     Objects = Objects -> Pnext;
  124.     }
  125. /*****************************************************************************
  126. * Routine to draw one object Object.                         *
  127. *****************************************************************************/
  128. static void DrawOneObject(IPObjectStruct *PObject)
  129.     IPPolygonStruct *PList = PObject -> PPolygon;
  130.     GGMySetColor(PObject -> Color);
  131.     while (PList) {
  132.     DrawOnePolygon(PList);
  133.     PList =    PList -> Pnext;
  134.     }
  135. /*****************************************************************************
  136. * Routine to draw one polygon, using global Matrix transform Mat.         *
  137. * Note this is the routine that    makes the real drawing...             *
  138. *****************************************************************************/
  139. static void DrawOnePolygon(IPPolygonStruct *PPolygon)
  140.     int    i, j, DrawNextEdge, NumOfVertices;
  141.     RealType MappedNormal[3], PolyNormal[3];
  142.     IPVertexStruct
  143.     *VList = PPolygon -> PVertex,
  144.     *VHead = VList;
  145.     if (VList == NULL) return;
  146.     TestQuitView();
  147.     switch (PPolygon -> Type) {
  148.     case IP_POINTLIST:
  149.         MoveToPtr(VList -> Coord);
  150.         DrawToPtr(VList -> Coord);
  151.         VList = VList -> Pnext;
  152.         for (i = 0;
  153.          i < GlblNumEdges && VList != NULL && VList != VHead;
  154.          i++) {
  155.         MoveToPtr(VList -> Coord);
  156.         DrawToPtr(VList -> Coord);
  157.         VList = VList -> Pnext;
  158.         }
  159.         break;
  160.     case IP_POLYLINE:
  161.         MoveToPtr(VList -> Coord);
  162.         DrawNextEdge = !IP_IS_VRTX_INTERNAL(VList);
  163.         VList = VList -> Pnext;
  164.         for (i = 1;
  165.          i < GlblNumEdges && VList != NULL && VList != VHead;
  166.          i++) {
  167.         if (DrawNextEdge || GlblInternal)
  168.             DrawToPtr(VList -> Coord);
  169.         else
  170.             MoveToPtr(VList -> Coord);
  171.         DrawNextEdge = !IP_IS_VRTX_INTERNAL(VList);
  172.         VList = VList -> Pnext;
  173.         }
  174.         break;
  175.     case IP_POLYGON:
  176. #ifdef __GL__
  177.         if (GlblDrawSolid) {
  178.         GGMyDrawPolygonSolid(PPolygon);
  179.         break;
  180.         }
  181. #endif
  182.         if (GlblDrawPNormal && IP_HAS_POLY_PLANE(PPolygon)) {
  183.         /* Sum all points to be averaged for normal position. */
  184.         for (i = 0; i < 3; i++) PolyNormal[i] = VList -> Coord[i];
  185.         NumOfVertices = 1;
  186.         }
  187.         MoveToPtr(VList -> Coord);
  188.         DrawNextEdge = !IP_IS_VRTX_INTERNAL(VList);
  189.         VList = VList -> Pnext;
  190.         for (i = 1;
  191.          i < GlblNumEdges && VList != NULL && VList != VHead;
  192.          i++) {
  193.         if (DrawNextEdge || GlblInternal)
  194.             DrawToPtr(VList -> Coord);
  195.         else
  196.             MoveToPtr(VList -> Coord);
  197.         if (GlblDrawVNormal && IP_HAS_VRTX_NORMAL(VList)) {
  198.             for (j = 0; j < 3; j++) MappedNormal[j] =
  199.             VList -> Coord[j] + VList -> Normal[j] * GlblNormalLen;
  200.             j = GlblClosedObject;
  201.             GlblClosedObject = FALSE;
  202.             DrawToPtr(MappedNormal);
  203.             MoveToPtr(VList -> Coord);
  204.             GlblClosedObject = j;
  205.         if (GlblDrawPNormal && IP_HAS_POLY_PLANE(PPolygon)) {
  206.             for (j = 0; j < 3; j++) PolyNormal[j] += VList -> Coord[j];
  207.             NumOfVertices++;
  208.         DrawNextEdge = !IP_IS_VRTX_INTERNAL(VList);
  209.         VList = VList -> Pnext;
  210.         }
  211.         if (GlblNumEdges > i) {
  212.         /* Close polygon by drawing a line to first vertex. */
  213.         if (DrawNextEdge || GlblInternal)
  214.             DrawToPtr(VHead -> Coord);
  215.         else
  216.             MoveToPtr(VHead -> Coord);
  217.         if (GlblDrawVNormal && IP_HAS_VRTX_NORMAL(VList)) {
  218.             for (j = 0; j < 3; j++) MappedNormal[j] =
  219.             VList -> Coord[j] + VList -> Normal[j] * GlblNormalLen;
  220.             j = GlblClosedObject;
  221.             GlblClosedObject = FALSE;
  222.             DrawToPtr(MappedNormal);
  223.             MoveToPtr(VList -> Coord);
  224.             GlblClosedObject = j;
  225.         }
  226.         if (GlblDrawPNormal && IP_HAS_POLY_PLANE(PPolygon)) {
  227.         for (i = 0; i < 3; i++) PolyNormal[i] /= NumOfVertices;
  228.         MoveToPtr(PolyNormal);
  229.         for (i = 0; i < 3; i++)
  230.                 PolyNormal[i] += PPolygon -> Plane[i] * GlblNormalLen;
  231.         i = GlblClosedObject;
  232.         GlblClosedObject = FALSE;
  233.         DrawToPtr(PolyNormal);
  234.         GlblClosedObject = i;
  235.         }
  236.         break;
  237.     }
  238.     MultVecby4by4(LastCoord, Coord, CrntViewMat);   /* Set last point coord. */
  239. #define MAX_NUM_ATTRS        10
  240. /*****************************************************************************
  241. * Attributes - geometry types (Surfaces/Curves/Polygons/Polylines) have this *
  242. * structure for keeping general attributes like colors etc.             *
  243. *****************************************************************************/
  244. typedef struct AttributeStruct {
  245.     ByteType Color;                       /* Color of geometry. */
  246.     ByteType NumStrAttribs;
  247.     char *StrAttrName[MAX_NUM_ATTRS + 1];        /* Generic string attrs. */
  248.     char *StrAttrData[MAX_NUM_ATTRS + 1];
  249. } AttributeStruct;
  250. MAX_NUM_ATTRS
  251.     if (IritPrsrWasPrspMat)
  252.     MultTwo4by4(GlblViewMat, IritPrsrViewMat, IritPrsrPrspMat);
  253.     else
  254.     GEN_COPY(GlblViewMat, IritPrsrViewMat, sizeof(MatrixType));
  255. #define GEN_COPY(Dest, Src, Size) memcpy(Dest, Src, Size)
  256. static int TransColorTable[][4] = {
  257.     { /* BLACK        */ 0,    0,   0,   0 },
  258.     { /* BLUE        */ 1,    0,   0, 255 },
  259.     { /* GREEN        */ 2,    0, 255,   0 },
  260.     { /* CYAN        */ 3,    0, 255, 255 },
  261.     { /* RED        */ 4,  255,   0,   0 },
  262.     { /* MAGENTA     */ 5,  255,   0, 255 },
  263.     { /* BROWN        */ 6,   50,   0,   0 },
  264.     { /* LIGHTGRAY    */ 7,  127, 127, 127 },
  265.     { /* DARKGRAY    */ 8,   63,  63,  63 },
  266.     { /* LIGHTBLUE    */ 9,    0,   0, 255 },
  267.     { /* LIGHTGREEN    */ 10,   0, 255,   0 },
  268.     { /* LIGHTCYAN    */ 11,   0, 255, 255 },
  269.     { /* LIGHTRED    */ 12, 255,   0,   0 },
  270.     { /* LIGHTMAGENTA    */ 13, 255,   0, 255 },
  271.     { /* YELLOW        */ 14, 255, 255,   0 },
  272.     { /* WHITE        */ 15, 255, 255, 255 },
  273.     { /* BROWN        */ 20,  50,   0,   0 },
  274.     { /* DARKGRAY    */ 56,  63,  63,  63 },
  275.     { /* LIGHTBLUE    */ 57,   0,   0, 255 },
  276.     { /* LIGHTGREEN    */ 58,   0, 255,   0 },
  277.     { /* LIGHTCYAN    */ 59,   0, 255, 255 },
  278.     { /* LIGHTRED    */ 60, 255,   0,   0 },
  279.     { /* LIGHTMAGENTA    */ 61, 255,   0, 255 },
  280.     { /* YELLOW        */ 62, 255, 255,   0 },
  281.     { /* WHITE        */ 63, 255, 255, 255 },
  282.     {               -1,   0,   0,   0 }
  283. /*****************************************************************************
  284. *  Routine to calculate the cross product of two vectors:                    *
  285. * Note Vres might be the same as V1 or V2 !                                  *
  286. *****************************************************************************/
  287. void VecCrossProd(VectorType Vres, VectorType V1, VectorType V2)
  288.     VectorType Vtemp;
  289.     Vtemp[0] = V1[1] * V2[2] - V2[1] * V1[2];
  290.     Vtemp[1] = V1[2] * V2[0] - V2[2] * V1[0];
  291.     Vtemp[2] = V1[0] * V2[1] - V2[0] * V1[1];
  292.     VecCopy(Vres, Vtemp);
  293. #define DOT_PROD(Pt1, Pt2)    (Pt1[0] * Pt2[0] + \
  294.                  Pt1[1] * Pt2[1] + \
  295.                  Pt1[2] * Pt2[2])
  296.